var express = require("express");
var router = express.Router();
const Mongoose = require("mongoose");
var Sow = require("../db/sow");
const fetch = require("node-fetch");
const multer = require("multer");
const fs = require("fs");
const path = require("path");
const cors = require("cors");
const Tesseract = require('tesseract.js');
const mammoth = require('mammoth');

// 在路由前添加CORS中间件
router.use(
  cors({
    origin: ["http://localhost:5173", "http://localhost:3000"], // 允许的前端域名
    credentials: true,
  })
);

// 添加请求日志中间件
router.use((req, res, next) => {
  console.log(`${new Date().toISOString()} - ${req.method} ${req.path}`);
  next();
});

// DeepSeek API 配置
const DEEPSEEK_API_KEY = "sk-bf8373d53a7b43aa9321ee1c14411e8f";
const DEEPSEEK_API_URL = "https://api.deepseek.com/chat/completions";

// 配置multer用于文件上传
const upload = multer({
  dest: "uploads/", // 上传文件临时存储目录
  limits: {
    fileSize: 20 * 1024 * 1024, // 限制文件大小为20MB
  },
  fileFilter: (req, file, cb) => {
    // 支持更多文件类型
    const allowedMimeTypes = [
      // 图片类型
      'image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp',
      'image/bmp', 'image/tiff', 'image/svg+xml', 'image/x-icon',
      'image/vnd.microsoft.icon', 'image/heic', 'image/heif',
      // 文档类型
      'text/plain', 'text/csv', 'application/csv',
      'application/pdf', 'application/msword',
      'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
      'application/vnd.ms-excel',
      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
      // Word文档
      'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
    ];
    
    if (allowedMimeTypes.includes(file.mimetype) || 
        file.mimetype.startsWith("image/") || 
        file.mimetype.startsWith("text/")) {
      cb(null, true);
    } else {
      cb(new Error("支持的文件类型：图片、文本、CSV、PDF、Word、Excel等"), false);
    }
  },
});

// 将图片文件转换为base64
const convertImageToBase64 = (filePath) => {
  try {
    const imageBuffer = fs.readFileSync(filePath);
    const base64String = imageBuffer.toString("base64");
    
    // 根据文件扩展名确定MIME类型
    const ext = path.extname(filePath).toLowerCase();
    let mimeType = "image/jpeg"; // 默认值
    
    const mimeTypeMap = {
      '.png': 'image/png',
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.gif': 'image/gif',
      '.webp': 'image/webp',
      '.bmp': 'image/bmp',
      '.tiff': 'image/tiff',
      '.tif': 'image/tiff',
      '.svg': 'image/svg+xml',
      '.ico': 'image/x-icon',
      '.heic': 'image/heic',
      '.heif': 'image/heif'
    };
    
    if (mimeTypeMap[ext]) {
      mimeType = mimeTypeMap[ext];
    }
    
    const dataUrl = `data:${mimeType};base64,${base64String}`;

    // 验证 base64 格式
    if (!dataUrl.startsWith("data:image/")) {
      throw new Error("无效的图片格式");
    }

    console.log("图片转换成功:", {
      mimeType,
      size: base64String.length,
      preview: dataUrl.substring(0, 50) + "...",
    });

    return dataUrl;
  } catch (error) {
    console.error("图片转换失败:", error);
    throw new Error("图片转换失败");
  }
};

// 清理临时文件
const cleanupFile = (filePath) => {
  if (filePath && fs.existsSync(filePath)) {
    try {
      fs.unlinkSync(filePath);
      console.log("临时文件已清理:", filePath);
    } catch (cleanupError) {
      console.error("清理临时文件失败:", cleanupError);
    }
  }
};

// 通用文件内容提取函数
async function extractFileContent(filePath, mimeType, originalName) {
  const fileExt = path.extname(originalName).toLowerCase();
  let content = "";
  let analysisResult = "";
  
  try {
    if (mimeType.startsWith('image/')) {
      // OCR识别逻辑
      const { data: { text } } = await Tesseract.recognize(filePath, 'chi_sim+eng');
      content = text.trim();
      analysisResult = content ? `📄 **OCR识别内容：**\n${content}\n\n` : 
        `📷 **图片信息：**\n- 文件名：${originalName}\n- 格式：${mimeType}\n\n`;
    } else if (fileExt === '.txt' || mimeType === 'text/plain') {
      // 文本文件处理
      content = fs.readFileSync(filePath, 'utf8');
      const preview = content.length > 1000 ? content.substring(0, 1000) + '...' : content;
      analysisResult = `📄 **文本文件内容：**\n${preview}\n\n`;
    } else if (fileExt === '.csv' || mimeType.includes('csv')) {
      // CSV文件处理
      content = fs.readFileSync(filePath, 'utf8');
      const lines = content.split('\n').slice(0, 10);
      const preview = lines.join('\n');
      analysisResult = `📊 **CSV文件内容预览：**\n${preview}\n${content.split('\n').length > 10 ? '...（显示前10行）' : ''}\n\n`;
    } else if (fileExt === '.docx') {
      // Word文档处理
      const result = await mammoth.extractRawText({ path: filePath });
      content = result.value;
      const preview = content.length > 2000 ? content.substring(0, 2000) + '...' : content;
      analysisResult = `📄 **Word文档内容：**\n${preview}\n\n`;
    } else {
      // 其他文件类型
      analysisResult = `📁 **文件信息：**\n- 文件名：${originalName}\n- 类型：${mimeType}\n\n`;
    }
  } catch (error) {
    console.error('文件内容提取失败:', error);
    analysisResult = `📁 **文件信息：**\n- 文件名：${originalName}\n- 处理失败：${error.message}\n\n`;
  }
  
  return { content, analysisResult };
}

// 通用DeepSeek API调用函数
async function callDeepSeekAPI(messages, maxTokens = 2000, temperature = 0.3) {
  const requestBody = {
    model: "deepseek-chat",
    messages: messages,
    max_tokens: maxTokens,
    temperature: temperature
  };

  const response = await fetch(DEEPSEEK_API_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${DEEPSEEK_API_KEY}`,
      "Accept": "application/json",
    },
    body: JSON.stringify(requestBody),
  });

  if (!response.ok) {
    throw new Error(`DeepSeek API请求失败: ${response.status}`);
  }

  const data = await response.json();
  
  if (!data.choices || !data.choices[0] || !data.choices[0].message) {
    throw new Error("AI分析响应格式异常");
  }
  
  return data.choices[0].message.content;
}

// 添加简单的内存缓存
const responseCache = new Map();
const CACHE_DURATION = 5 * 60 * 1000; // 5分钟缓存

// 生成缓存键
function generateCacheKey(message, chatHistory) {
  return Buffer.from(JSON.stringify({ message, chatHistory })).toString('base64');
}

// 统一的回退分析函数
async function fallbackAnalysis(req, res, fileName, userText = null) {
  try {
    const fileExt = path.extname(fileName).toLowerCase();
    let analysisPrompt = `用户上传了一张图片文件：${fileName}。`;
    
    if (userText) {
      analysisPrompt += `\n用户的问题是：${userText}\n\n`;
    }
    
    analysisPrompt += `请根据文件信息${userText ? '和用户问题' : ''}提供相应的建议和分析。`;
    
    const aiResponse = await callDeepSeekAPI([
      {
        role: "system",
        content: "你是一个智能助手，能够根据用户提供的信息给出有用的建议和分析。请用中文回答。"
      },
      {
        role: "user",
        content: analysisPrompt
      }
    ], 1500, 0.5);
    
    res.json({
      success: true,
      data: {
        analysis: aiResponse,
        timestamp: new Date(),
        analysisType: 'fallback',
        imageInfo: {
          originalName: fileName,
          note: '基于文件名的分析'
        },
        userText: userText
      }
    });
  } catch (error) {
    console.error('回退分析失败:', error);
    res.status(500).json({
      success: false,
      error: "分析功能暂时不可用，请稍后重试"
    });
  }
}

// AI文本对话接口
router.post("/api/chat", async (req, res) => {
  try {
    const { message, chatHistory = [] } = req.body;

    if (!message || typeof message !== "string") {
      return res.status(400).json({
        success: false,
        error: "消息内容不能为空",
      });
    }

    // 检查缓存
    const cacheKey = generateCacheKey(message, chatHistory);
    const cached = responseCache.get(cacheKey);
    
    if (cached && (Date.now() - cached.timestamp) < CACHE_DURATION) {
      console.log('返回缓存响应');
      return res.json({
        success: true,
        data: {
          content: cached.content,
          timestamp: new Date(),
          fromCache: true
        },
      });
    }

    // 构建对话历史
    const messages = [
      {
        role: "system",
        content:
          "你是一个专业的医疗健康助手，请用中文回答用户的健康相关问题。请提供准确、有用的医疗建议，但也要提醒用户在必要时咨询专业医生。",
      },
      ...chatHistory.map((chat) => ({
        role: chat.role,
        content: chat.content,
      })),
      {
        role: "user",
        content: message,
      },
    ];

    const requestBody = {
      model: "deepseek-chat",
      messages: messages,
      max_tokens: 2000,
      temperature: 0.7,
      stream: false,
    };

    console.log("发送对话请求到DeepSeek API...");

    const response = await fetch(DEEPSEEK_API_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${DEEPSEEK_API_KEY}`,
        Accept: "application/json",
      },
      body: JSON.stringify(requestBody),
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error("DeepSeek API错误:", errorText);
      throw new Error(`API请求失败: ${response.status}`);
    }

    const data = await response.json();
    console.log("DeepSeek API响应成功");

    if (data.choices && data.choices.length > 0 && data.choices[0].message) {
      const content = data.choices[0].message.content;
      
      // 缓存响应
      responseCache.set(cacheKey, {
        content: content,
        timestamp: Date.now()
      });
      
      // 清理过期缓存
      for (const [key, value] of responseCache.entries()) {
        if (Date.now() - value.timestamp > CACHE_DURATION) {
          responseCache.delete(key);
        }
      }
      
      res.json({
        success: true,
        data: {
          content: content,
          timestamp: new Date(),
          fromCache: false
        },
      });
    } else {
      throw new Error("API响应格式异常");
    }
  } catch (error) {
    console.error("对话接口错误:", error);

    let errorMessage = "AI对话失败";
    if (error.message.includes("fetch")) {
      errorMessage = "网络连接失败，请检查网络连接";
    } else if (error instanceof Error) {
      errorMessage = error.message;
    }

    res.status(500).json({
      success: false,
      error: errorMessage,
    });
  }
});

// 图片分析接口 - 支持任意类型图片分析
// 删除这个接口 - 视觉AI分析
// router.post("/api/analyze-image", upload.single("image"), async (req, res) => {
//   ... 整个接口代码都要删除 ...
// });

// 删除这个接口 - 图片+文字分析  
// router.post("/api/analyze-image-with-text", upload.single("image"), async (req, res) => {
//   ... 整个接口代码都要删除 ...
// });

// OCR图片分析接口
router.post("/api/analyze-image-ocr", upload.single("image"), async (req, res) => {
  let tempFilePath = null;

  try {
    if (!req.file) {
      return res.status(400).json({
        success: false,
        error: "请上传图片文件",
      });
    }

    tempFilePath = req.file.path;
    console.log("开始OCR识别...");

    // 使用Tesseract进行OCR识别
    const { data: { text } } = await Tesseract.recognize(tempFilePath, 'chi_sim+eng', {
      logger: m => console.log(m)
    });

    console.log("OCR识别结果:", text);

    if (!text.trim()) {
      throw new Error("图片中未识别到文字内容");
    }

    // 将OCR结果发送给DeepSeek进行分析
    const requestBody = {
      model: "deepseek-chat",
      messages: [
        {
          role: "system",
          content: "你是一个专业的医疗健康助手。用户上传了一张图片，我已经通过OCR识别出了其中的文字内容。请根据这些文字内容进行医疗健康分析，提供专业建议。"
        },
        {
          role: "user",
          content: `请分析以下从图片中识别出的文字内容，并提供医疗健康建议：\n\n${text}`
        }
      ],
      max_tokens: 1000,
      temperature: 0.3
    };

    const response = await fetch(DEEPSEEK_API_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${DEEPSEEK_API_KEY}`,
        "Accept": "application/json",
      },
      body: JSON.stringify(requestBody),
    });

    const data = await response.json();
    
    if (data.choices && data.choices.length > 0) {
      res.json({
        success: true,
        data: {
          analysis: `📄 内容：\n${text}\n\n🔍 **AI分析结果：**\n${data.choices[0].message.content}`,
          timestamp: new Date(),
          model: "ocr+deepseek",
          ocrText: text
        }
      });
    } else {
      throw new Error("AI分析失败");
    }
  } catch (error) {
    console.error("OCR图片分析错误:", error);
    return await fallbackTextAnalysis(req, res, req.file?.originalname || "未知文件");
  } finally {
    cleanupFile(tempFilePath);
  }
});

// 健康小贴士接口
router.get("/api/health-tip", (req, res) => {
  res.json({
    success: true,
    data: {
      tip: "您的血压指标近期有波动，建议及时进行复查并...",
      timestamp: new Date(),
    },
  });
});

// 药品信息接口
router.get("/api/medicine-info", (req, res) => {
  res.json({
    success: true,
    data: {
      title: "阿司匹林服用小贴士：",
      content:
        "阿司匹林是一种常见的解热镇痛药，但它的使用方法和注意事项却常常被人们忽视。",
      timestamp: new Date(),
    },
  });
});

// 示例问题接口
router.get("/api/example-questions", (req, res) => {
  res.json({
    success: true,
    data: ["请分析我最近7天的健康数据", "嗓子疼，需要注意什么？"],
  });
});

// 优化错误处理
router.use((error, req, res, next) => {
  console.error("路由错误:", error);
  res.status(500).json({
    success: false,
    error: "服务器内部错误",
  });
});

module.exports = router;

// 简化后的文件分析接口
router.post("/api/analyze-file", upload.single("file"), async (req, res) => {
  let tempFilePath = null;
  
  try {
    if (!req.file) {
      return res.status(400).json({ success: false, error: "请上传文件" });
    }
    
    tempFilePath = req.file.path;
    const userMessage = req.body.message || "请分析这个文件";
    
    // 使用公共函数提取文件内容
    const { content, analysisResult } = await extractFileContent(
      tempFilePath, 
      req.file.mimetype, 
      req.file.originalname
    );
    
    // 构建分析消息
    const messages = [
      {
        role: "system",
        content: "你是一个专业的文件分析助手，请根据文件内容提供有价值的分析和建议。"
      },
      {
        role: "user",
        content: `${userMessage}\n\n**文件详情：**\n${analysisResult}`
      }
    ];
    
    // 调用AI分析
    const aiAnalysis = await callDeepSeekAPI(messages);
    
    res.json({
      success: true,
      data: {
        analysis: `📁 **文件分析结果**\n\n${analysisResult}🤖 **AI深度分析：**\n${aiAnalysis}`,
        timestamp: new Date(),
        fileInfo: {
          originalName: req.file.originalname,
          mimeType: req.file.mimetype,
          size: req.file.size
        }
      }
    });
  } catch (error) {
    console.error("文件分析错误:", error);
    res.status(500).json({ success: false, error: error.message || "文件分析失败" });
  } finally {
    cleanupFile(tempFilePath);
  }
});

// 文件+文字组合分析接口
router.post("/api/analyze-file-with-text", upload.single("file"), async (req, res) => {
  let tempFilePath = null;

  try {
    if (!req.file) {
      return res.status(400).json({
        success: false,
        error: "请上传文件",
      });
    }

    tempFilePath = req.file.path;
    const fileExt = path.extname(req.file.originalname).toLowerCase();
    const userMessage = req.body.message || "请分析这个文件";
    const analysisType = req.body.analysisType || "general";
    
    let analysisResult = "";
    let fileContent = "";
    
    console.log('开始处理文件+文字分析:', {
      originalName: req.file.originalname,
      mimeType: req.file.mimetype,
      size: req.file.size,
      extension: fileExt,
      userMessage: userMessage,
      analysisType: analysisType
    });
    
    // 根据文件类型选择不同的处理方式
    if (req.file.mimetype.startsWith('image/')) {
      // 图片文件使用 OCR 分析
      try {
        console.log('开始OCR识别...');
        const { data: { text } } = await Tesseract.recognize(tempFilePath, 'chi_sim+eng', {
          logger: m => console.log('OCR进度:', m)
        });
        
        if (text && text.trim()) {
          fileContent = text.trim();
          analysisResult = `📄 **OCR识别内容：**\n${fileContent}\n\n`;
        } else {
          analysisResult = `📷 **图片信息：**\n- 文件名：${req.file.originalname}\n- 格式：${req.file.mimetype}\n- 大小：${(req.file.size / 1024).toFixed(2)}KB\n\n`;
        }
      } catch (ocrError) {
        console.error('OCR识别失败:', ocrError);
        analysisResult = `📷 **图片信息：**\n- 文件名：${req.file.originalname}\n- 格式：${req.file.mimetype}\n- 大小：${(req.file.size / 1024).toFixed(2)}KB\n- OCR识别失败，将基于图片信息和用户问题进行分析\n\n`;
      }
    } else if (fileExt === '.txt' || req.file.mimetype === 'text/plain') {
      // 文本文件直接读取内容
      try {
        fileContent = fs.readFileSync(tempFilePath, 'utf8');
        const preview = fileContent.length > 1000 ? fileContent.substring(0, 1000) + '...' : fileContent;
        analysisResult = `📄 **文本文件内容：**\n${preview}\n\n`;
      } catch (readError) {
        console.error('文本文件读取失败:', readError);
        analysisResult = `📄 **文本文件信息：**\n- 文件名：${req.file.originalname}\n- 读取失败，将基于文件信息和用户问题进行分析\n\n`;
      }
    } else if (fileExt === '.csv' || req.file.mimetype.includes('csv')) {
      // CSV文件处理
      try {
        fileContent = fs.readFileSync(tempFilePath, 'utf8');
        const lines = fileContent.split('\n').slice(0, 10); // 只显示前10行
        const preview = lines.join('\n');
        analysisResult = `📊 **CSV文件内容预览：**\n${preview}\n${fileContent.split('\n').length > 10 ? '...（显示前10行）' : ''}\n\n`;
      } catch (readError) {
        console.error('CSV文件读取失败:', readError);
        analysisResult = `📊 **CSV文件信息：**\n- 文件名：${req.file.originalname}\n- 读取失败，将基于文件信息和用户问题进行分析\n\n`;
      }
    } else if (fileExt === '.docx' || req.file.mimetype === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document') {
      // Word文档处理
      try {
        console.log('开始解析Word文档...');
        const result = await mammoth.extractRawText({ path: tempFilePath });
        fileContent = result.value;
        
        if (fileContent && fileContent.trim()) {
          const preview = fileContent.length > 2000 ? fileContent.substring(0, 2000) + '...' : fileContent;
          analysisResult = `📄 **Word文档内容：**\n${preview}\n${fileContent.length > 2000 ? '...（显示前2000字符）' : ''}\n\n`;
          console.log('Word文档解析成功，内容长度:', fileContent.length);
        } else {
          analysisResult = `📄 **Word文档信息：**\n- 文件名：${req.file.originalname}\n- 文档为空或解析失败\n\n`;
        }
      } catch (docError) {
        console.error('Word文档解析失败:', docError);
        analysisResult = `📄 **Word文档信息：**\n- 文件名：${req.file.originalname}\n- 解析失败：${docError.message}\n- 将基于文件信息和用户问题进行分析\n\n`;
      }
    } else if (fileExt === '.doc') {
      // 旧版Word文档提示
      analysisResult = `📄 **Word文档信息：**\n- 文件名：${req.file.originalname}\n- 格式：旧版Word文档(.doc)\n- 建议：请将文档转换为.docx格式以获得更好的解析效果\n\n`;
    } else {
      // 其他文件类型
      analysisResult = `📁 **文件信息：**\n- 文件名：${req.file.originalname}\n- 类型：${req.file.mimetype}\n- 大小：${(req.file.size / 1024).toFixed(2)}KB\n\n`;
    }
    
    // 根据分析类型构建不同的系统提示
    let systemPrompt = "";
    switch (analysisType) {
      case 'medical':
        systemPrompt = `你是一个专业的医疗健康分析助手，擅长分析医疗相关的文件和数据。请根据用户上传的文件内容和提出的问题，提供专业的医疗健康建议。

分析要求：
1. 如果是医疗报告或检查结果，请详细解读各项指标
2. 如果是症状描述，请提供可能的原因和建议
3. 如果是药物信息，请说明用法用量和注意事项
4. 提供专业但易懂的健康建议
5. 必要时建议就医或咨询专业医生

请用中文回答，语言要专业但通俗易懂。`;
        break;
      case 'technical':
        systemPrompt = `你是一个专业的技术文档分析助手，擅长分析各种技术文件和代码。请根据用户上传的文件内容和提出的问题，提供专业的技术分析和建议。

分析要求：
1. 如果是代码文件，请分析代码结构和功能
2. 如果是技术文档，请总结关键技术点
3. 如果是配置文件，请解释配置项的作用
4. 提供技术改进建议和最佳实践
5. 指出潜在的问题和解决方案

请用中文回答，语言要专业准确。`;
        break;
      default: // general
        systemPrompt = `你是一个专业的文件分析助手，擅长分析各种类型的文件内容。请根据用户上传的文件和提出的具体问题，提供有价值的见解和建议。

分析要求：
1. 仔细分析文件内容和用户的具体问题
2. 提供针对性的回答和建议
3. 如果是数据文件，请分析数据特征和趋势
4. 如果是文档，请总结主要内容和要点
5. 提供实用的建议和下一步行动建议

请用中文回答，语言要专业但易懂。`;
    }
    
    const userPrompt = `**用户问题：** ${userMessage}\n\n**文件详情：**\n- 文件名：${req.file.originalname}\n- 文件类型：${req.file.mimetype}\n- 文件大小：${(req.file.size / 1024).toFixed(2)}KB\n\n${analysisResult}\n请根据以上文件内容和我的问题进行详细分析。`;

    const requestBody = {
      model: "deepseek-chat",
      messages: [
        {
          role: "system",
          content: systemPrompt
        },
        {
          role: "user",
          content: userPrompt
        }
      ],
      max_tokens: 2000,
      temperature: 0.3
    };

    console.log('发送AI分析请求...');
    const response = await fetch(DEEPSEEK_API_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${DEEPSEEK_API_KEY}`,
        "Accept": "application/json",
      },
      body: JSON.stringify(requestBody),
    });

    if (!response.ok) {
      throw new Error(`AI API请求失败: ${response.status}`);
    }

    const data = await response.json();
    
    if (data.choices && data.choices.length > 0 && data.choices[0].message) {
      const aiAnalysis = data.choices[0].message.content;
      
      res.json({
        success: true,
        data: {
          analysis: `\n${aiAnalysis}`,
          timestamp: new Date(),
          analysisType: analysisType,
          fileInfo: {
            originalName: req.file.originalname,
            mimeType: req.file.mimetype,
            size: req.file.size,
            extension: fileExt
          },
          userMessage: userMessage,
          extractedContent: fileContent ? fileContent.substring(0, 500) : null
        }
      });
    } else {
      throw new Error("AI分析响应格式异常");
    }
  } catch (error) {
    console.error("文件+文字分析错误:", error);
    
    let errorMessage = "文件分析失败";
    if (error.message.includes('fetch')) {
      errorMessage = "网络连接失败，请检查网络连接";
    } else if (error instanceof Error) {
      errorMessage = error.message;
    }
    
    res.status(500).json({
      success: false,
      error: errorMessage
    });
  } finally {
    cleanupFile(tempFilePath);
  }
});



// 图片综合分析接口 - 支持OCR识别 + 用户文字描述 + AI智能分析
router.post("/api/analyze-image-comprehensive", upload.single("image"), async (req, res) => {
  let tempFilePath = null;

  try {
    if (!req.file) {
      return res.status(400).json({
        success: false,
        error: "请上传图片文件",
      });
    }

    tempFilePath = req.file.path;
    const userMessage = req.body.message || "请分析这张图片";
    const analysisType = req.body.analysisType || "comprehensive";
    
    console.log("开始综合图片分析...", {
      fileName: req.file.originalname,
      userMessage,
      analysisType
    });

    // 1. 使用Tesseract进行OCR识别
    let ocrText = "";
    try {
      const { data: { text } } = await Tesseract.recognize(tempFilePath, 'chi_sim+eng', {
        logger: m => console.log('OCR进度:', m)
      });
      ocrText = text.trim();
      console.log("OCR识别结果:", ocrText);
    } catch (ocrError) {
      console.warn("OCR识别失败，将进行基础分析:", ocrError.message);
    }

    // 2. 构建综合分析提示词
    let analysisPrompt = "";
    
    if (ocrText) {
      analysisPrompt = `用户上传了一张图片，并提供了以下描述："${userMessage}"

通过OCR技术，我从图片中识别出以下文字内容：
${ocrText}

请结合用户的描述和图片中的文字内容，进行综合分析并提供专业建议。`;
    } else {
      analysisPrompt = `用户上传了一张图片，并提供了以下描述："${userMessage}"

虽然无法从图片中识别出文字内容，但请根据用户的描述和图片的基本信息（文件名：${req.file.originalname}），提供相应的分析和建议。`;
    }

    // 3. 调用DeepSeek API进行智能分析
    const requestBody = {
      model: "deepseek-chat",
      messages: [
        {
          role: "system",
          content: "你是一个专业的智能分析助手，能够结合图片中的文字内容和用户描述进行综合分析。请提供准确、有用的分析结果和建议。如果涉及医疗健康内容，请给出专业的健康建议。"
        },
        {
          role: "user",
          content: analysisPrompt
        }
      ],
      max_tokens: 1500,
      temperature: 0.3
    };

    const response = await fetch(DEEPSEEK_API_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${DEEPSEEK_API_KEY}`,
        "Accept": "application/json",
      },
      body: JSON.stringify(requestBody),
    });

    if (!response.ok) {
      throw new Error(`DeepSeek API请求失败: ${response.status}`);
    }

    const data = await response.json();
    
    if (data.choices && data.choices.length > 0) {
      // 构建完整的分析结果
      let fullAnalysis = "";
      
      // if (ocrText) {
      //   fullAnalysis += `📄 **图片文字内容：**\n${ocrText}\n\n`;
      // }
      
      fullAnalysis += `💭 **用户描述：**\n${userMessage}\n\n`;
      fullAnalysis += `🔍 **AI综合分析：**\n${data.choices[0].message.content}`;
      
      res.json({
        success: true,
        data: {
          analysis: fullAnalysis,
          timestamp: new Date(),
          model: "comprehensive",
          ocrText: ocrText,
          userMessage: userMessage,
          analysisType: analysisType
        }
      });
    } else {
      throw new Error("AI分析失败");
    }
  } catch (error) {
    console.error("综合图片分析错误:", error);
    
    // 回退到基础分析
    return await fallbackAnalysis(req, res, req.file?.originalname || "未知文件", userMessage);
  } finally {
    cleanupFile(tempFilePath);
  }
});



// 图片综合分析接口 - 支持OCR识别 + 用户文字描述 + AI智能分析
router.post("/api/analyze-image-comprehensive", upload.single("image"), async (req, res) => {
  let tempFilePath = null;

  try {
    if (!req.file) {
      return res.status(400).json({
        success: false,
        error: "请上传图片文件",
      });
    }

    tempFilePath = req.file.path;
    const userMessage = req.body.message || "请分析这张图片";
    const analysisType = req.body.analysisType || "comprehensive";
    
    console.log("开始综合图片分析...", {
      fileName: req.file.originalname,
      userMessage,
      analysisType
    });

    // 1. 使用Tesseract进行OCR识别
    let ocrText = "";
    try {
      const { data: { text } } = await Tesseract.recognize(tempFilePath, 'chi_sim+eng', {
        logger: m => console.log('OCR进度:', m)
      });
      ocrText = text.trim();
      console.log("OCR识别结果:", ocrText);
    } catch (ocrError) {
      console.warn("OCR识别失败，将进行基础分析:", ocrError.message);
    }

    // 2. 构建综合分析提示词
    let analysisPrompt = "";
    
    if (ocrText) {
      analysisPrompt = `用户上传了一张图片，并提供了以下描述："${userMessage}"

通过OCR技术，我从图片中识别出以下文字内容：
${ocrText}

请结合用户的描述和图片中的文字内容，进行综合分析并提供专业建议。`;
    } else {
      analysisPrompt = `用户上传了一张图片，并提供了以下描述："${userMessage}"

虽然无法从图片中识别出文字内容，但请根据用户的描述和图片的基本信息（文件名：${req.file.originalname}），提供相应的分析和建议。`;
    }

    // 3. 调用DeepSeek API进行智能分析
    const requestBody = {
      model: "deepseek-chat",
      messages: [
        {
          role: "system",
          content: "你是一个专业的智能分析助手，能够结合图片中的文字内容和用户描述进行综合分析。请提供准确、有用的分析结果和建议。如果涉及医疗健康内容，请给出专业的健康建议。"
        },
        {
          role: "user",
          content: analysisPrompt
        }
      ],
      max_tokens: 1500,
      temperature: 0.3
    };

    const response = await fetch(DEEPSEEK_API_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${DEEPSEEK_API_KEY}`,
        "Accept": "application/json",
      },
      body: JSON.stringify(requestBody),
    });

    if (!response.ok) {
      throw new Error(`DeepSeek API请求失败: ${response.status}`);
    }

    const data = await response.json();
    
    if (data.choices && data.choices.length > 0) {
      // 构建完整的分析结果
      let fullAnalysis = "";
      
      // if (ocrText) {
      //   fullAnalysis += `📄 **图片文字内容：**\n${ocrText}\n\n`;
      // }
      
      fullAnalysis += `💭 **用户描述：**\n${userMessage}\n\n`;
      fullAnalysis += `🔍 **AI综合分析：**\n${data.choices[0].message.content}`;
      
      res.json({
        success: true,
        data: {
          analysis: fullAnalysis,
          timestamp: new Date(),
          model: "comprehensive",
          ocrText: ocrText,
          userMessage: userMessage,
          analysisType: analysisType
        }
      });
    } else {
      throw new Error("AI分析失败");
    }
  } catch (error) {
    console.error("综合图片分析错误:", error);
    
    // 回退到基础分析
    return await fallbackAnalysis(req, res, req.file?.originalname || "未知文件", userMessage);
  } finally {
    cleanupFile(tempFilePath);
  }
});

// 文生图（Text-to-Image）实现

// 1. 技术选型

// 推荐的文生图API服务：
// - **DALL-E 3** (OpenAI) - 质量最高
// - **Midjourney API** - 艺术效果好
// - **Stable Diffusion** - 开源免费
// - **文心一格** (百度) - 中文支持好
// - **通义万相** (阿里) - 国内服务稳定

// 2. 后端实现 (AI.js
router.post("/api/text-to-image", async (req, res) => {
  try {
    const { prompt, style = "realistic", size = "1024x1024" } = req.body;

    if (!prompt || typeof prompt !== "string") {
      return res.status(400).json({
        success: false,
        error: "请提供文字描述",
      });
    }

    console.log("开始文生图请求:", { prompt, style, size });

    // 使用DALL-E 3 API示例
    const response = await fetch("https://api.openai.com/v1/images/generations", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
      },
      body: JSON.stringify({
        model: "dall-e-3",
        prompt: prompt,
        n: 1,
        size: size,
        quality: "standard",
        style: style === "artistic" ? "vivid" : "natural"
      }),
    });

    if (!response.ok) {
      const errorData = await response.text();
      console.error("文生图API错误:", errorData);
      throw new Error(`API请求失败: ${response.status}`);
    }

    const data = await response.json();

    if (data.data && data.data.length > 0) {
      res.json({
        success: true,
        data: {
          imageUrl: data.data[0].url,
          prompt: prompt,
          timestamp: new Date(),
          model: "dall-e-3"
        },
      });
    } else {
      throw new Error("生成图片失败");
    }
  } catch (error) {
    console.error("文生图接口错误:", error);
    res.status(500).json({
      success: false,
      error: error.message || "图片生成失败",
    });
  }
});

// 使用Stable Diffusion的替代方案
router.post("/api/text-to-image-sd", async (req, res) => {
  try {
    const { prompt, negative_prompt = "", steps = 20 } = req.body;

    // 使用Stability AI API
    const response = await fetch("https://api.stability.ai/v1/generation/stable-diffusion-xl-1024-v1-0/text-to-image", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${process.env.STABILITY_API_KEY}`,
      },
      body: JSON.stringify({
        text_prompts: [
          {
            text: prompt,
            weight: 1
          },
          {
            text: negative_prompt,
            weight: -1
          }
        ],
        cfg_scale: 7,
        height: 1024,
        width: 1024,
        steps: steps,
        samples: 1
      }),
    });

    if (!response.ok) {
      throw new Error(`Stability AI API错误: ${response.status}`);
    }

    const data = await response.json();
    const imageBase64 = data.artifacts[0].base64;

    res.json({
      success: true,
      data: {
        imageBase64: `data:image/png;base64,${imageBase64}`,
        prompt: prompt,
        timestamp: new Date(),
        model: "stable-diffusion-xl"
      },
    });
  } catch (error) {
    console.error("Stable Diffusion文生图错误:", error);
    res.status(500).json({
      success: false,
      error: error.message || "图片生成失败",
    });
  }
});

const Core = require('@alicloud/pop-core');

// 阿里云配置
const ALIBABA_ACCESS_KEY_ID = '2439571';
const ALIBABA_ACCESS_KEY_SECRET = 'sk-ff198c91a17c41cba8a0d4841ac55ffa';
const ALIBABA_ENDPOINT = 'https://wanx.cn-hangzhou.aliyuncs.com';

// 创建阿里云客户端
const alibabaClient = new Core({
  accessKeyId: ALIBABA_ACCESS_KEY_ID,
  accessKeySecret: ALIBABA_ACCESS_KEY_SECRET,
  endpoint: ALIBABA_ENDPOINT,
  apiVersion: '2023-08-01'
});

// 阿里云通义万相文生图接口
router.post("/api/alibaba-text-to-image", async (req, res) => {
  try {
    const { prompt, style = "<auto>", size = "1024*1024", n = 1 } = req.body;

    if (!prompt || typeof prompt !== "string") {
      return res.status(400).json({
        success: false,
        error: "请提供文字描述",
      });
    }

    console.log("开始阿里云文生图请求:", { prompt, style, size, n });

    // 调用阿里云通义万相API
    const params = {
      'RegionId': 'cn-hangzhou',
      'Model': 'wanx-v1',
      'Input': {
        'prompt': prompt,
        'negative_prompt': '', // 负面提示词
        'ref_img': '' // 参考图片（可选）
      },
      'Parameters': {
        'style': style, // 风格：<auto>、<sketch>、<anime>、<oil painting>、<watercolor>、<chinese painting>等
        'size': size, // 尺寸：1024*1024、720*1280、1280*720
        'n': n, // 生成图片数量
        'seed': Math.floor(Math.random() * 1000000), // 随机种子
        'ref_strength': 0.5, // 参考强度
        'ref_mode': 'repaint' // 参考模式
      }
    };

    const requestOption = {
      method: 'POST',
      formatParams: false,
    };

    const result = await alibabaClient.request('CreateImageSynthesisTask', params, requestOption);
    
    if (result.Code === 'Success') {
      // 获取任务ID
      const taskId = result.Data.TaskId;
      
      // 轮询检查任务状态
      let taskResult = null;
      let attempts = 0;
      const maxAttempts = 30; // 最多等待30次，每次2秒
      
      while (attempts < maxAttempts) {
        await new Promise(resolve => setTimeout(resolve, 2000)); // 等待2秒
        
        const statusParams = {
          'RegionId': 'cn-hangzhou',
          'TaskId': taskId
        };
        
        const statusResult = await alibabaClient.request('GetImageSynthesisTask', statusParams, requestOption);
        
        if (statusResult.Data.TaskStatus === 'SUCCEEDED') {
          taskResult = statusResult;
          break;
        } else if (statusResult.Data.TaskStatus === 'FAILED') {
          throw new Error('图片生成失败');
        }
        
        attempts++;
      }
      
      if (!taskResult) {
        throw new Error('图片生成超时');
      }
      
      // 返回生成的图片URL
      const imageUrls = taskResult.Data.ImageUrls;
      
      res.json({
        success: true,
        data: {
          imageUrls: imageUrls,
          taskId: taskId,
          prompt: prompt,
          style: style,
          timestamp: new Date(),
          model: "wanx-v1"
        },
      });
      
    } else {
      throw new Error(result.Message || '调用阿里云API失败');
    }
    
  } catch (error) {
    console.error("阿里云文生图接口错误:", error);
    res.status(500).json({
      success: false,
      error: error.message || "图片生成失败",
    });
  }
});

// 简化版阿里云文生图接口（使用HTTP直接调用）
router.post("/api/alibaba-text-to-image-simple", async (req, res) => {
  try {
    const { prompt, style = "<auto>", size = "1024*1024" } = req.body;

    if (!prompt || typeof prompt !== "string") {
      return res.status(400).json({
        success: false,
        error: "请提供文字描述",
      });
    }

    console.log("开始阿里云文生图请求:", { prompt, style, size });

    // 使用阿里云通义万相的HTTP API
    const response = await fetch('https://dashscope.aliyuncs.com/api/v1/services/aigc/text2image/image-synthesis', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${ALIBABA_ACCESS_KEY_SECRET}`, // 使用API Key
        'Content-Type': 'application/json',
        'X-DashScope-Async': 'enable' // 启用异步模式
      },
      body: JSON.stringify({
        model: 'wanx-v1',
        input: {
          prompt: prompt
        },
        parameters: {
          style: style,
          size: size,
          n: 1
        }
      })
    });

    if (!response.ok) {
      const errorData = await response.text();
      console.error("阿里云API错误:", errorData);
      throw new Error(`API请求失败: ${response.status}`);
    }

    const data = await response.json();
    
    if (data.output && data.output.task_id) {
      // 异步任务，需要轮询结果
      const taskId = data.output.task_id;
      
      // 轮询检查任务状态
      let attempts = 0;
      const maxAttempts = 30;
      
      while (attempts < maxAttempts) {
        await new Promise(resolve => setTimeout(resolve, 2000));
        
        const statusResponse = await fetch(`https://dashscope.aliyuncs.com/api/v1/tasks/${taskId}`, {
          method: 'GET',
          headers: {
            'Authorization': `Bearer ${ALIBABA_ACCESS_KEY_SECRET}`
          }
        });
        
        const statusData = await statusResponse.json();
        
        if (statusData.output && statusData.output.task_status === 'SUCCEEDED') {
          res.json({
            success: true,
            data: {
              imageUrls: statusData.output.results.map(result => result.url),
              taskId: taskId,
              prompt: prompt,
              style: style,
              timestamp: new Date(),
              model: "wanx-v1"
            },
          });
          return;
        } else if (statusData.output && statusData.output.task_status === 'FAILED') {
          throw new Error('图片生成失败');
        }
        
        attempts++;
      }
      
      throw new Error('图片生成超时');
      
    } else {
      throw new Error('获取任务ID失败');
    }
    
  } catch (error) {
    console.error("阿里云文生图接口错误:", error);
    res.status(500).json({
      success: false,
      error: error.message || "图片生成失败",
    });
  }
});
